﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a matrix.</summary>
	// Token: 0x02000047 RID: 71
	[Serializable]
	public class HMatrix : HHandle, ISerializable, ICloneable
	{
		// Token: 0x06000980 RID: 2432 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMatrix() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x06000981 RID: 2433 RVA: 0x0003D71E File Offset: 0x0003B91E
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMatrix(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000982 RID: 2434 RVA: 0x0003D72D File Offset: 0x0003B92D
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMatrix(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000983 RID: 2435 RVA: 0x0003D73C File Offset: 0x0003B93C
		private void AssertSemType()
		{
			base.AssertSemType("matrix");
		}

		// Token: 0x06000984 RID: 2436 RVA: 0x0003D749 File Offset: 0x0003B949
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HMatrix obj)
		{
			obj = new HMatrix(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06000985 RID: 2437 RVA: 0x0003D764 File Offset: 0x0003B964
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HMatrix[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HMatrix[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HMatrix(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read a matrix from a file.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000986 RID: 2438 RVA: 0x0003D7D4 File Offset: 0x0003B9D4
		public HMatrix(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(842);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a matrix.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="rows">Number of rows of the matrix. Default: 3</param>
		/// <param name="columns">Number of columns of the matrix. Default: 3</param>
		/// <param name="value">Values for initializing the elements of the matrix. Default: 0</param>
		// Token: 0x06000987 RID: 2439 RVA: 0x0003D820 File Offset: 0x0003BA20
		public HMatrix(int rows, int columns, HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(897);
			HalconAPI.StoreI(proc, 0, rows);
			HalconAPI.StoreI(proc, 1, columns);
			HalconAPI.Store(proc, 2, value);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(value);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a matrix.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="rows">Number of rows of the matrix. Default: 3</param>
		/// <param name="columns">Number of columns of the matrix. Default: 3</param>
		/// <param name="value">Values for initializing the elements of the matrix. Default: 0</param>
		// Token: 0x06000988 RID: 2440 RVA: 0x0003D884 File Offset: 0x0003BA84
		public HMatrix(int rows, int columns, double value)
		{
			IntPtr proc = HalconAPI.PreCall(897);
			HalconAPI.StoreI(proc, 0, rows);
			HalconAPI.StoreI(proc, 1, columns);
			HalconAPI.StoreD(proc, 2, value);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x06000989 RID: 2441 RVA: 0x0003D8E0 File Offset: 0x0003BAE0
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeMatrix();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x0600098A RID: 2442 RVA: 0x0003D918 File Offset: 0x0003BB18
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMatrix(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeMatrix(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x0600098B RID: 2443 RVA: 0x0003D958 File Offset: 0x0003BB58
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeMatrix();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x0600098C RID: 2444 RVA: 0x0003D96C File Offset: 0x0003BB6C
		public new static HMatrix Deserialize(Stream stream)
		{
			HMatrix hmatrix = new HMatrix();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hmatrix.DeserializeMatrix(hserializedItem);
			hserializedItem.Dispose();
			return hmatrix;
		}

		// Token: 0x0600098D RID: 2445 RVA: 0x0003D992 File Offset: 0x0003BB92
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x0600098E RID: 2446 RVA: 0x0003D99C File Offset: 0x0003BB9C
		public new HMatrix Clone()
		{
			HSerializedItem hserializedItem = this.SerializeMatrix();
			HMatrix hmatrix = new HMatrix();
			hmatrix.DeserializeMatrix(hserializedItem);
			hserializedItem.Dispose();
			return hmatrix;
		}

		/// <summary>Negate the matrix</summary>
		// Token: 0x0600098F RID: 2447 RVA: 0x0003D9C2 File Offset: 0x0003BBC2
		public static HMatrix operator -(HMatrix matrix)
		{
			return matrix.ScaleMatrix(-1.0);
		}

		/// <summary>Add two matrices</summary>
		// Token: 0x06000990 RID: 2448 RVA: 0x0003D9D3 File Offset: 0x0003BBD3
		public static HMatrix operator +(HMatrix matrix1, HMatrix matrix2)
		{
			return matrix1.AddMatrix(matrix2);
		}

		/// <summary>Subtract two matrices</summary>
		// Token: 0x06000991 RID: 2449 RVA: 0x0003D9DC File Offset: 0x0003BBDC
		public static HMatrix operator -(HMatrix matrix1, HMatrix matrix2)
		{
			return matrix1.SubMatrix(matrix2);
		}

		/// <summary>Multiplies two matrices</summary>
		// Token: 0x06000992 RID: 2450 RVA: 0x0003D9E5 File Offset: 0x0003BBE5
		public static HMatrix operator *(HMatrix matrix1, HMatrix matrix2)
		{
			return matrix1.MultMatrix(matrix2, "AB");
		}

		/// <summary>Scale a matrix</summary>
		// Token: 0x06000993 RID: 2451 RVA: 0x0003D9F3 File Offset: 0x0003BBF3
		public static HMatrix operator *(double factor, HMatrix matrix)
		{
			return matrix.ScaleMatrix(factor);
		}

		/// <summary>Scale a matrix</summary>
		// Token: 0x06000994 RID: 2452 RVA: 0x0003D9FC File Offset: 0x0003BBFC
		public static HMatrix operator *(HMatrix matrix, double factor)
		{
			return matrix.ScaleMatrix(factor);
		}

		/// <summary>Solve linear system matrix2 * x = matrix1</summary>
		// Token: 0x06000995 RID: 2453 RVA: 0x0003DA05 File Offset: 0x0003BC05
		public static HMatrix operator /(HMatrix matrix1, HMatrix matrix2)
		{
			return matrix2.SolveMatrix("general", 0.0, matrix1);
		}

		/// <summary>Indexer for accessing matrix elements</summary>
		// Token: 0x1700004B RID: 75
		public double this[int row, int column]
		{
			get
			{
				return this.GetValueMatrix(row, column);
			}
			set
			{
				this.SetValueMatrix(row, column, value);
			}
		}

		/// <summary>Get the number of rows</summary>
		// Token: 0x1700004C RID: 76
		// (get) Token: 0x06000998 RID: 2456 RVA: 0x0003DA34 File Offset: 0x0003BC34
		public int NumRows
		{
			get
			{
				int result;
				int num;
				this.GetSizeMatrix(out result, out num);
				return result;
			}
		}

		/// <summary>Get the number of columns</summary>
		// Token: 0x1700004D RID: 77
		// (get) Token: 0x06000999 RID: 2457 RVA: 0x0003DA4C File Offset: 0x0003BC4C
		public int NumColumns
		{
			get
			{
				int num;
				int result;
				this.GetSizeMatrix(out num, out result);
				return result;
			}
		}

		/// <summary>
		///   Deserialize a serialized matrix.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x0600099A RID: 2458 RVA: 0x0003DA64 File Offset: 0x0003BC64
		public void DeserializeMatrix(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(840);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a matrix.
		///   Instance represents: Matrix handle.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x0600099B RID: 2459 RVA: 0x0003DAB8 File Offset: 0x0003BCB8
		public HSerializedItem SerializeMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(841);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read a matrix from a file.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x0600099C RID: 2460 RVA: 0x0003DB00 File Offset: 0x0003BD00
		public void ReadMatrix(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(842);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write a matrix to a file.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="fileFormat">Format of the file. Default: "binary"</param>
		/// <param name="fileName">File name.</param>
		// Token: 0x0600099D RID: 2461 RVA: 0x0003DB4C File Offset: 0x0003BD4C
		public void WriteMatrix(string fileFormat, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(843);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileFormat);
			HalconAPI.StoreS(proc, 2, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Perform an orthogonal decomposition of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="decompositionType">Method of decomposition. Default: "qr"</param>
		/// <param name="outputMatricesType">Type of output matrices. Default: "full"</param>
		/// <param name="computeOrthogonal">Computation of the orthogonal matrix. Default: "true"</param>
		/// <param name="matrixTriangularID">Matrix handle with the triangular part of the decomposed input matrix.</param>
		/// <returns>Matrix handle with the orthogonal part of the decomposed input matrix.</returns>
		// Token: 0x0600099E RID: 2462 RVA: 0x0003DB90 File Offset: 0x0003BD90
		public HMatrix OrthogonalDecomposeMatrix(string decompositionType, string outputMatricesType, string computeOrthogonal, out HMatrix matrixTriangularID)
		{
			IntPtr proc = HalconAPI.PreCall(844);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, decompositionType);
			HalconAPI.StoreS(proc, 2, outputMatricesType);
			HalconAPI.StoreS(proc, 3, computeOrthogonal);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			num = HMatrix.LoadNew(proc, 1, num, out matrixTriangularID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Decompose a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">Type of the input matrix. Default: "general"</param>
		/// <param name="matrix2ID">Matrix handle with the output matrix 2.</param>
		/// <returns>Matrix handle with the output matrix 1.</returns>
		// Token: 0x0600099F RID: 2463 RVA: 0x0003DC04 File Offset: 0x0003BE04
		public HMatrix DecomposeMatrix(string matrixType, out HMatrix matrix2ID)
		{
			IntPtr proc = HalconAPI.PreCall(845);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			num = HMatrix.LoadNew(proc, 1, num, out matrix2ID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the singular value decomposition of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="SVDType">Type of computation. Default: "full"</param>
		/// <param name="computeSingularVectors">Computation of singular values. Default: "both"</param>
		/// <param name="matrixSID">Matrix handle with singular values.</param>
		/// <param name="matrixVID">Matrix handle with the right singular vectors.</param>
		/// <returns>Matrix handle with the left singular vectors.</returns>
		// Token: 0x060009A0 RID: 2464 RVA: 0x0003DC68 File Offset: 0x0003BE68
		public HMatrix SvdMatrix(string SVDType, string computeSingularVectors, out HMatrix matrixSID, out HMatrix matrixVID)
		{
			IntPtr proc = HalconAPI.PreCall(846);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, SVDType);
			HalconAPI.StoreS(proc, 2, computeSingularVectors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			num = HMatrix.LoadNew(proc, 1, num, out matrixSID);
			num = HMatrix.LoadNew(proc, 2, num, out matrixVID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the generalized eigenvalues and optionally the generalized eigenvectors of general matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <param name="computeEigenvectors">Computation of the eigenvectors. Default: "none"</param>
		/// <param name="eigenvaluesRealID">Matrix handle with the real parts of the eigenvalues.</param>
		/// <param name="eigenvaluesImagID">Matrix handle with the imaginary parts of the eigenvalues.</param>
		/// <param name="eigenvectorsRealID">Matrix handle with the real parts of the eigenvectors.</param>
		/// <param name="eigenvectorsImagID">Matrix handle with the imaginary parts of the eigenvectors.</param>
		// Token: 0x060009A1 RID: 2465 RVA: 0x0003DCE8 File Offset: 0x0003BEE8
		public void GeneralizedEigenvaluesGeneralMatrix(HMatrix matrixBID, string computeEigenvectors, out HMatrix eigenvaluesRealID, out HMatrix eigenvaluesImagID, out HMatrix eigenvectorsRealID, out HMatrix eigenvectorsImagID)
		{
			IntPtr proc = HalconAPI.PreCall(847);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.StoreS(proc, 2, computeEigenvectors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HMatrix.LoadNew(proc, 0, num, out eigenvaluesRealID);
			num = HMatrix.LoadNew(proc, 1, num, out eigenvaluesImagID);
			num = HMatrix.LoadNew(proc, 2, num, out eigenvectorsRealID);
			num = HMatrix.LoadNew(proc, 3, num, out eigenvectorsImagID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
		}

		/// <summary>
		///   Compute the generalized eigenvalues and optionally generalized eigenvectors of symmetric input matrices.
		///   Instance represents: Matrix handle of the symmetric input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the symmetric positive definite input matrix B.</param>
		/// <param name="computeEigenvectors">Computation of the eigenvectors. Default: "false"</param>
		/// <param name="eigenvectorsID">Matrix handle with the eigenvectors.</param>
		/// <returns>Matrix handle with the eigenvalues.</returns>
		// Token: 0x060009A2 RID: 2466 RVA: 0x0003DD80 File Offset: 0x0003BF80
		public HMatrix GeneralizedEigenvaluesSymmetricMatrix(HMatrix matrixBID, string computeEigenvectors, out HMatrix eigenvectorsID)
		{
			IntPtr proc = HalconAPI.PreCall(848);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.StoreS(proc, 2, computeEigenvectors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			num = HMatrix.LoadNew(proc, 1, num, out eigenvectorsID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
			return result;
		}

		/// <summary>
		///   Compute the eigenvalues and optionally the eigenvectors of a general matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="computeEigenvectors">Computation of the eigenvectors. Default: "none"</param>
		/// <param name="eigenvaluesRealID">Matrix handle with the real parts of the eigenvalues.</param>
		/// <param name="eigenvaluesImagID">Matrix handle with the imaginary parts of the eigenvalues.</param>
		/// <param name="eigenvectorsRealID">Matrix handle with the real parts of the eigenvectors.</param>
		/// <param name="eigenvectorsImagID">Matrix handle with the imaginary parts of the eigenvectors.</param>
		// Token: 0x060009A3 RID: 2467 RVA: 0x0003DDF0 File Offset: 0x0003BFF0
		public void EigenvaluesGeneralMatrix(string computeEigenvectors, out HMatrix eigenvaluesRealID, out HMatrix eigenvaluesImagID, out HMatrix eigenvectorsRealID, out HMatrix eigenvectorsImagID)
		{
			IntPtr proc = HalconAPI.PreCall(849);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, computeEigenvectors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HMatrix.LoadNew(proc, 0, num, out eigenvaluesRealID);
			num = HMatrix.LoadNew(proc, 1, num, out eigenvaluesImagID);
			num = HMatrix.LoadNew(proc, 2, num, out eigenvectorsRealID);
			num = HMatrix.LoadNew(proc, 3, num, out eigenvectorsImagID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the eigenvalues and optionally eigenvectors of a symmetric matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="computeEigenvectors">Computation of the eigenvectors. Default: "false"</param>
		/// <param name="eigenvectorsID">Matrix handle with the eigenvectors.</param>
		/// <returns>Matrix handle with the eigenvalues.</returns>
		// Token: 0x060009A4 RID: 2468 RVA: 0x0003DE78 File Offset: 0x0003C078
		public HMatrix EigenvaluesSymmetricMatrix(string computeEigenvectors, out HMatrix eigenvectorsID)
		{
			IntPtr proc = HalconAPI.PreCall(850);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, computeEigenvectors);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			num = HMatrix.LoadNew(proc, 1, num, out eigenvectorsID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the solution of a system of equations.
		///   Instance represents: Matrix handle of the input matrix of the left hand side.
		/// </summary>
		/// <param name="matrixLHSType">The type of the input matrix of the left hand side. Default: "general"</param>
		/// <param name="epsilon">Type of solving and limitation to set singular values to be 0. Default: 0.0</param>
		/// <param name="matrixRHSID">Matrix handle of the input matrix of right hand side.</param>
		/// <returns>New matrix handle with the solution.</returns>
		// Token: 0x060009A5 RID: 2469 RVA: 0x0003DEDC File Offset: 0x0003C0DC
		public HMatrix SolveMatrix(string matrixLHSType, double epsilon, HMatrix matrixRHSID)
		{
			IntPtr proc = HalconAPI.PreCall(851);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixLHSType);
			HalconAPI.StoreD(proc, 2, epsilon);
			HalconAPI.Store(proc, 3, matrixRHSID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixRHSID);
			return result;
		}

		/// <summary>
		///   Compute the determinant of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <returns>Determinant of the input matrix.</returns>
		// Token: 0x060009A6 RID: 2470 RVA: 0x0003DF44 File Offset: 0x0003C144
		public double DeterminantMatrix(string matrixType)
		{
			IntPtr proc = HalconAPI.PreCall(852);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Invert a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <param name="epsilon">Type of inversion. Default: 0.0</param>
		// Token: 0x060009A7 RID: 2471 RVA: 0x0003DF94 File Offset: 0x0003C194
		public void InvertMatrixMod(string matrixType, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(853);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.StoreD(proc, 2, epsilon);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Invert a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <param name="epsilon">Type of inversion. Default: 0.0</param>
		/// <returns>Matrix handle with the inverse matrix.</returns>
		// Token: 0x060009A8 RID: 2472 RVA: 0x0003DFD8 File Offset: 0x0003C1D8
		public HMatrix InvertMatrix(string matrixType, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(854);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.StoreD(proc, 2, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transpose a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		// Token: 0x060009A9 RID: 2473 RVA: 0x0003E030 File Offset: 0x0003C230
		public void TransposeMatrixMod()
		{
			IntPtr proc = HalconAPI.PreCall(855);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Transpose a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <returns>Matrix handle with the transpose of the input matrix.</returns>
		// Token: 0x060009AA RID: 2474 RVA: 0x0003E064 File Offset: 0x0003C264
		public HMatrix TransposeMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(856);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Returns the elementwise maximum of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="maxType">Type of maximum determination. Default: "columns"</param>
		/// <returns>Matrix handle with the maximum values of the input matrix.</returns>
		// Token: 0x060009AB RID: 2475 RVA: 0x0003E0AC File Offset: 0x0003C2AC
		public HMatrix MaxMatrix(string maxType)
		{
			IntPtr proc = HalconAPI.PreCall(857);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, maxType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Returns the elementwise minimum of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="minType">Type of minimum determination. Default: "columns"</param>
		/// <returns>Matrix handle with the minimum values of the input matrix.</returns>
		// Token: 0x060009AC RID: 2476 RVA: 0x0003E0FC File Offset: 0x0003C2FC
		public HMatrix MinMatrix(string minType)
		{
			IntPtr proc = HalconAPI.PreCall(858);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, minType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the power functions of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <param name="power">The power. Default: 2.0</param>
		// Token: 0x060009AD RID: 2477 RVA: 0x0003E14C File Offset: 0x0003C34C
		public void PowMatrixMod(string matrixType, HTuple power)
		{
			IntPtr proc = HalconAPI.PreCall(859);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.Store(proc, 2, power);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(power);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the power functions of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <param name="power">The power. Default: 2.0</param>
		// Token: 0x060009AE RID: 2478 RVA: 0x0003E198 File Offset: 0x0003C398
		public void PowMatrixMod(string matrixType, double power)
		{
			IntPtr proc = HalconAPI.PreCall(859);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.StoreD(proc, 2, power);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the power functions of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <param name="power">The power. Default: 2.0</param>
		/// <returns>Matrix handle with the raised powered matrix.</returns>
		// Token: 0x060009AF RID: 2479 RVA: 0x0003E1DC File Offset: 0x0003C3DC
		public HMatrix PowMatrix(string matrixType, HTuple power)
		{
			IntPtr proc = HalconAPI.PreCall(860);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.Store(proc, 2, power);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(power);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the power functions of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixType">The type of the input matrix. Default: "general"</param>
		/// <param name="power">The power. Default: 2.0</param>
		/// <returns>Matrix handle with the raised powered matrix.</returns>
		// Token: 0x060009B0 RID: 2480 RVA: 0x0003E23C File Offset: 0x0003C43C
		public HMatrix PowMatrix(string matrixType, double power)
		{
			IntPtr proc = HalconAPI.PreCall(860);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, matrixType);
			HalconAPI.StoreD(proc, 2, power);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the power functions of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix of the base.
		/// </summary>
		/// <param name="matrixExpID">Matrix handle of the input matrix with exponents.</param>
		// Token: 0x060009B1 RID: 2481 RVA: 0x0003E294 File Offset: 0x0003C494
		public void PowElementMatrixMod(HMatrix matrixExpID)
		{
			IntPtr proc = HalconAPI.PreCall(861);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixExpID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixExpID);
		}

		/// <summary>
		///   Compute the power functions of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix of the base.
		/// </summary>
		/// <param name="matrixExpID">Matrix handle of the input matrix with exponents.</param>
		/// <returns>Matrix handle with the raised power of the input matrix.</returns>
		// Token: 0x060009B2 RID: 2482 RVA: 0x0003E2D8 File Offset: 0x0003C4D8
		public HMatrix PowElementMatrix(HMatrix matrixExpID)
		{
			IntPtr proc = HalconAPI.PreCall(862);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixExpID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixExpID);
			return result;
		}

		/// <summary>
		///   Compute the power functions of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="power">The power. Default: 2.0</param>
		// Token: 0x060009B3 RID: 2483 RVA: 0x0003E330 File Offset: 0x0003C530
		public void PowScalarElementMatrixMod(HTuple power)
		{
			IntPtr proc = HalconAPI.PreCall(863);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, power);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(power);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the power functions of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="power">The power. Default: 2.0</param>
		// Token: 0x060009B4 RID: 2484 RVA: 0x0003E374 File Offset: 0x0003C574
		public void PowScalarElementMatrixMod(double power)
		{
			IntPtr proc = HalconAPI.PreCall(863);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, power);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the power functions of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="power">The power. Default: 2.0</param>
		/// <returns>Matrix handle with the raised power of the input matrix.</returns>
		// Token: 0x060009B5 RID: 2485 RVA: 0x0003E3B0 File Offset: 0x0003C5B0
		public HMatrix PowScalarElementMatrix(HTuple power)
		{
			IntPtr proc = HalconAPI.PreCall(864);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, power);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(power);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the power functions of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="power">The power. Default: 2.0</param>
		/// <returns>Matrix handle with the raised power of the input matrix.</returns>
		// Token: 0x060009B6 RID: 2486 RVA: 0x0003E408 File Offset: 0x0003C608
		public HMatrix PowScalarElementMatrix(double power)
		{
			IntPtr proc = HalconAPI.PreCall(864);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, power);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the square root values of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		// Token: 0x060009B7 RID: 2487 RVA: 0x0003E458 File Offset: 0x0003C658
		public void SqrtMatrixMod()
		{
			IntPtr proc = HalconAPI.PreCall(865);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the square root values of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <returns>Matrix handle with the square root values of the input matrix.</returns>
		// Token: 0x060009B8 RID: 2488 RVA: 0x0003E48C File Offset: 0x0003C68C
		public HMatrix SqrtMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(866);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the absolute values of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		// Token: 0x060009B9 RID: 2489 RVA: 0x0003E4D4 File Offset: 0x0003C6D4
		public void AbsMatrixMod()
		{
			IntPtr proc = HalconAPI.PreCall(867);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the absolute values of the elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <returns>Matrix handle with the absolute values of the input matrix.</returns>
		// Token: 0x060009BA RID: 2490 RVA: 0x0003E508 File Offset: 0x0003C708
		public HMatrix AbsMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(868);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Norm of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="normType">Type of norm. Default: "2-norm"</param>
		/// <returns>Norm of the input matrix.</returns>
		// Token: 0x060009BB RID: 2491 RVA: 0x0003E550 File Offset: 0x0003C750
		public double NormMatrix(string normType)
		{
			IntPtr proc = HalconAPI.PreCall(869);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, normType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Returns the elementwise mean of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="meanType">Type of mean determination. Default: "columns"</param>
		/// <returns>Matrix handle with the mean values of the input matrix.</returns>
		// Token: 0x060009BC RID: 2492 RVA: 0x0003E5A0 File Offset: 0x0003C7A0
		public HMatrix MeanMatrix(string meanType)
		{
			IntPtr proc = HalconAPI.PreCall(870);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, meanType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Returns the elementwise sum of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="sumType">Type of summation. Default: "columns"</param>
		/// <returns>Matrix handle with the sum of the input matrix.</returns>
		// Token: 0x060009BD RID: 2493 RVA: 0x0003E5F0 File Offset: 0x0003C7F0
		public HMatrix SumMatrix(string sumType)
		{
			IntPtr proc = HalconAPI.PreCall(871);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, sumType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Divide matrices element-by-element.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		// Token: 0x060009BE RID: 2494 RVA: 0x0003E640 File Offset: 0x0003C840
		public void DivElementMatrixMod(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(872);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
		}

		/// <summary>
		///   Divide matrices element-by-element.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <returns>Matrix handle with the divided values of input matrices.</returns>
		// Token: 0x060009BF RID: 2495 RVA: 0x0003E684 File Offset: 0x0003C884
		public HMatrix DivElementMatrix(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(873);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
			return result;
		}

		/// <summary>
		///   Multiply matrices element-by-element.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		// Token: 0x060009C0 RID: 2496 RVA: 0x0003E6DC File Offset: 0x0003C8DC
		public void MultElementMatrixMod(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(874);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
		}

		/// <summary>
		///   Multiply matrices element-by-element.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <returns>Matrix handle with the multiplied values of the input matrices.</returns>
		// Token: 0x060009C1 RID: 2497 RVA: 0x0003E720 File Offset: 0x0003C920
		public HMatrix MultElementMatrix(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(875);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
			return result;
		}

		/// <summary>
		///   Scale a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="factor">Scale factor. Default: 2.0</param>
		// Token: 0x060009C2 RID: 2498 RVA: 0x0003E778 File Offset: 0x0003C978
		public void ScaleMatrixMod(HTuple factor)
		{
			IntPtr proc = HalconAPI.PreCall(876);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, factor);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(factor);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Scale a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="factor">Scale factor. Default: 2.0</param>
		// Token: 0x060009C3 RID: 2499 RVA: 0x0003E7BC File Offset: 0x0003C9BC
		public void ScaleMatrixMod(double factor)
		{
			IntPtr proc = HalconAPI.PreCall(876);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, factor);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Scale a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="factor">Scale factor. Default: 2.0</param>
		/// <returns>Matrix handle with the scaled elements.</returns>
		// Token: 0x060009C4 RID: 2500 RVA: 0x0003E7F8 File Offset: 0x0003C9F8
		public HMatrix ScaleMatrix(HTuple factor)
		{
			IntPtr proc = HalconAPI.PreCall(877);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, factor);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(factor);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Scale a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="factor">Scale factor. Default: 2.0</param>
		/// <returns>Matrix handle with the scaled elements.</returns>
		// Token: 0x060009C5 RID: 2501 RVA: 0x0003E850 File Offset: 0x0003CA50
		public HMatrix ScaleMatrix(double factor)
		{
			IntPtr proc = HalconAPI.PreCall(877);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, factor);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Subtract two matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		// Token: 0x060009C6 RID: 2502 RVA: 0x0003E8A0 File Offset: 0x0003CAA0
		public void SubMatrixMod(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(878);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
		}

		/// <summary>
		///   Subtract two matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <returns>Matrix handle with the difference of the input matrices.</returns>
		// Token: 0x060009C7 RID: 2503 RVA: 0x0003E8E4 File Offset: 0x0003CAE4
		public HMatrix SubMatrix(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(879);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
			return result;
		}

		/// <summary>
		///   Add two matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		// Token: 0x060009C8 RID: 2504 RVA: 0x0003E93C File Offset: 0x0003CB3C
		public void AddMatrixMod(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(880);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
		}

		/// <summary>
		///   Add two matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <returns>Matrix handle with the sum of the input matrices.</returns>
		// Token: 0x060009C9 RID: 2505 RVA: 0x0003E980 File Offset: 0x0003CB80
		public HMatrix AddMatrix(HMatrix matrixBID)
		{
			IntPtr proc = HalconAPI.PreCall(881);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
			return result;
		}

		/// <summary>
		///   Multiply two matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <param name="multType">Type of the input matrices. Default: "AB"</param>
		// Token: 0x060009CA RID: 2506 RVA: 0x0003E9D8 File Offset: 0x0003CBD8
		public void MultMatrixMod(HMatrix matrixBID, string multType)
		{
			IntPtr proc = HalconAPI.PreCall(882);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.StoreS(proc, 2, multType);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
		}

		/// <summary>
		///   Multiply two matrices.
		///   Instance represents: Matrix handle of the input matrix A.
		/// </summary>
		/// <param name="matrixBID">Matrix handle of the input matrix B.</param>
		/// <param name="multType">Type of the input matrices. Default: "AB"</param>
		/// <returns>Matrix handle of the multiplied matrices.</returns>
		// Token: 0x060009CB RID: 2507 RVA: 0x0003EA24 File Offset: 0x0003CC24
		public HMatrix MultMatrix(HMatrix matrixBID, string multType)
		{
			IntPtr proc = HalconAPI.PreCall(883);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixBID);
			HalconAPI.StoreS(proc, 2, multType);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixBID);
			return result;
		}

		/// <summary>
		///   Get the size of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="rows">Number of rows of the matrix.</param>
		/// <param name="columns">Number of columns of the matrix.</param>
		// Token: 0x060009CC RID: 2508 RVA: 0x0003EA84 File Offset: 0x0003CC84
		public void GetSizeMatrix(out int rows, out int columns)
		{
			IntPtr proc = HalconAPI.PreCall(884);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out rows);
			num = HalconAPI.LoadI(proc, 1, num, out columns);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Repeat a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="rows">Number of copies of input matrix in row direction. Default: 2</param>
		/// <param name="columns">Number of copies of input matrix in column direction. Default: 2</param>
		/// <returns>Matrix handle of the repeated copied matrix.</returns>
		// Token: 0x060009CD RID: 2509 RVA: 0x0003EADC File Offset: 0x0003CCDC
		public HMatrix RepeatMatrix(int rows, int columns)
		{
			IntPtr proc = HalconAPI.PreCall(885);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, rows);
			HalconAPI.StoreI(proc, 2, columns);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Copy a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <returns>Matrix handle of the copied matrix.</returns>
		// Token: 0x060009CE RID: 2510 RVA: 0x0003EB34 File Offset: 0x0003CD34
		public HMatrix CopyMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(886);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set the diagonal elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="vectorID">Matrix handle containing the diagonal elements to be set.</param>
		/// <param name="diagonal">Position of the diagonal. Default: 0</param>
		// Token: 0x060009CF RID: 2511 RVA: 0x0003EB7C File Offset: 0x0003CD7C
		public void SetDiagonalMatrix(HMatrix vectorID, int diagonal)
		{
			IntPtr proc = HalconAPI.PreCall(887);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, vectorID);
			HalconAPI.StoreI(proc, 2, diagonal);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(vectorID);
		}

		/// <summary>
		///   Get the diagonal elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="diagonal">Number of the desired diagonal. Default: 0</param>
		/// <returns>Matrix handle containing the diagonal elements.</returns>
		// Token: 0x060009D0 RID: 2512 RVA: 0x0003EBC8 File Offset: 0x0003CDC8
		public HMatrix GetDiagonalMatrix(int diagonal)
		{
			IntPtr proc = HalconAPI.PreCall(888);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, diagonal);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set a sub-matrix of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="matrixSubID">Matrix handle of the input sub-matrix.</param>
		/// <param name="row">Upper row position of the sub-matrix in the matrix. Default: 0</param>
		/// <param name="column">Left column position of the sub-matrix in the matrix. Default: 0</param>
		// Token: 0x060009D1 RID: 2513 RVA: 0x0003EC18 File Offset: 0x0003CE18
		public void SetSubMatrix(HMatrix matrixSubID, int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(889);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, matrixSubID);
			HalconAPI.StoreI(proc, 2, row);
			HalconAPI.StoreI(proc, 3, column);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(matrixSubID);
		}

		/// <summary>
		///   Get a sub-matrix of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="row">Upper row position of the sub-matrix in the input matrix. Default: 0</param>
		/// <param name="column">Left column position of the sub-matrix in the input matrix. Default: 0</param>
		/// <param name="rowsSub">Number of rows of the sub-matrix. Default: 1</param>
		/// <param name="columnsSub">Number of columns of the sub-matrix. Default: 1</param>
		/// <returns>Matrix handle of the sub-matrix.</returns>
		// Token: 0x060009D2 RID: 2514 RVA: 0x0003EC6C File Offset: 0x0003CE6C
		public HMatrix GetSubMatrix(int row, int column, int rowsSub, int columnsSub)
		{
			IntPtr proc = HalconAPI.PreCall(890);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, rowsSub);
			HalconAPI.StoreI(proc, 4, columnsSub);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HMatrix result;
			num = HMatrix.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set all values of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="values">Values to be set.</param>
		// Token: 0x060009D3 RID: 2515 RVA: 0x0003ECD8 File Offset: 0x0003CED8
		public void SetFullMatrix(HTuple values)
		{
			IntPtr proc = HalconAPI.PreCall(891);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, values);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(values);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set all values of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="values">Values to be set.</param>
		// Token: 0x060009D4 RID: 2516 RVA: 0x0003ED1C File Offset: 0x0003CF1C
		public void SetFullMatrix(double values)
		{
			IntPtr proc = HalconAPI.PreCall(891);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, values);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return all values of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <returns>Values of the matrix elements.</returns>
		// Token: 0x060009D5 RID: 2517 RVA: 0x0003ED58 File Offset: 0x0003CF58
		public HTuple GetFullMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(892);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set one or more elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="row">Row numbers of the matrix elements to be modified. Default: 0</param>
		/// <param name="column">Column numbers of the matrix elements to be modified. Default: 0</param>
		/// <param name="value">Values to be set in the indicated matrix elements. Default: 0</param>
		// Token: 0x060009D6 RID: 2518 RVA: 0x0003EDA4 File Offset: 0x0003CFA4
		public void SetValueMatrix(HTuple row, HTuple column, HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(893);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(value);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set one or more elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="row">Row numbers of the matrix elements to be modified. Default: 0</param>
		/// <param name="column">Column numbers of the matrix elements to be modified. Default: 0</param>
		/// <param name="value">Values to be set in the indicated matrix elements. Default: 0</param>
		// Token: 0x060009D7 RID: 2519 RVA: 0x0003EE04 File Offset: 0x0003D004
		public void SetValueMatrix(int row, int column, double value)
		{
			IntPtr proc = HalconAPI.PreCall(893);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreD(proc, 3, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return one ore more elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="row">Row numbers of matrix elements to be returned. Default: 0</param>
		/// <param name="column">Column numbers of matrix elements to be returned. Default: 0</param>
		/// <returns>Values of indicated matrix elements.</returns>
		// Token: 0x060009D8 RID: 2520 RVA: 0x0003EE50 File Offset: 0x0003D050
		public HTuple GetValueMatrix(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(894);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return one ore more elements of a matrix.
		///   Instance represents: Matrix handle of the input matrix.
		/// </summary>
		/// <param name="row">Row numbers of matrix elements to be returned. Default: 0</param>
		/// <param name="column">Column numbers of matrix elements to be returned. Default: 0</param>
		/// <returns>Values of indicated matrix elements.</returns>
		// Token: 0x060009D9 RID: 2521 RVA: 0x0003EEB8 File Offset: 0x0003D0B8
		public double GetValueMatrix(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(894);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Free the memory of a matrix.</summary>
		/// <param name="matrixID">Matrix handle.</param>
		// Token: 0x060009DA RID: 2522 RVA: 0x0003EF10 File Offset: 0x0003D110
		public static void ClearMatrix(HMatrix[] matrixID)
		{
			HTuple htuple = HHandleBase.ConcatArray(matrixID);
			IntPtr proc = HalconAPI.PreCall(896);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(matrixID);
		}

		/// <summary>
		///   Free the memory of a matrix.
		///   Instance represents: Matrix handle.
		/// </summary>
		// Token: 0x060009DB RID: 2523 RVA: 0x0003EF54 File Offset: 0x0003D154
		public void ClearMatrix()
		{
			IntPtr proc = HalconAPI.PreCall(896);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a matrix.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="rows">Number of rows of the matrix. Default: 3</param>
		/// <param name="columns">Number of columns of the matrix. Default: 3</param>
		/// <param name="value">Values for initializing the elements of the matrix. Default: 0</param>
		// Token: 0x060009DC RID: 2524 RVA: 0x0003EF88 File Offset: 0x0003D188
		public void CreateMatrix(int rows, int columns, HTuple value)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(897);
			HalconAPI.StoreI(proc, 0, rows);
			HalconAPI.StoreI(proc, 1, columns);
			HalconAPI.Store(proc, 2, value);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(value);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a matrix.
		///   Modified instance represents: Matrix handle.
		/// </summary>
		/// <param name="rows">Number of rows of the matrix. Default: 3</param>
		/// <param name="columns">Number of columns of the matrix. Default: 3</param>
		/// <param name="value">Values for initializing the elements of the matrix. Default: 0</param>
		// Token: 0x060009DD RID: 2525 RVA: 0x0003EFEC File Offset: 0x0003D1EC
		public void CreateMatrix(int rows, int columns, double value)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(897);
			HalconAPI.StoreI(proc, 0, rows);
			HalconAPI.StoreI(proc, 1, columns);
			HalconAPI.StoreD(proc, 2, value);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}
	}
}
